/**
 * 数据存储工具模块
 * 处理交易对数据的持久化存储和监控日志记录
 */

const fs = require('fs');
const path = require('path');
const logger = require('./logger');

// 数据文件路径
const dataFilePath = path.join(__dirname, '../../data/trading_pairs.json');
const monitorLogPath = path.join(__dirname, '../../data/monitor_logs.json');

// 多交易所数据文件路径
const multiExchangeDataPath = path.join(__dirname, '../../data/exchanges');

/**
 * 确保数据目录存在
 */
function ensureDataDirectory() {
  const dataDir = path.dirname(dataFilePath);
  if (!fs.existsSync(dataDir)) {
    fs.mkdirSync(dataDir, { recursive: true });
    logger.debug('创建数据目录: ' + dataDir);
  }
  
  // 确保多交易所数据目录存在
  if (!fs.existsSync(multiExchangeDataPath)) {
    fs.mkdirSync(multiExchangeDataPath, { recursive: true });
    logger.debug('创建多交易所数据目录: ' + multiExchangeDataPath);
  }
}

/**
 * 读取上次保存的交易对数据
 * @param {string} exchangeId - 交易所ID（可选，不传则使用原始单交易所逻辑）
 * @returns {Set} 交易对集合
 */
function loadPreviousPairs(exchangeId = null) {
  try {
    ensureDataDirectory();
    
    let targetFile;
    let logPrefix;
    
    if (exchangeId) {
      // 多交易所模式
      targetFile = path.join(multiExchangeDataPath, `${exchangeId}_pairs.json`);
      logPrefix = `${exchangeId} `;
    } else {
      // 原始单交易所模式（向后兼容）
      targetFile = dataFilePath;
      logPrefix = '';
    }
    
    if (fs.existsSync(targetFile)) {
      const data = fs.readFileSync(targetFile, 'utf8');
      const parsedData = JSON.parse(data);
      
      // 处理新格式（包含元数据）和旧格式（纯数组）
      let pairs;
      if (Array.isArray(parsedData)) {
        // 旧格式：直接是数组
        pairs = parsedData;
      } else if (parsedData.pairs && Array.isArray(parsedData.pairs)) {
        // 新格式：包含元数据的对象
        pairs = parsedData.pairs;
      } else {
        throw new Error('数据格式不正确');
      }
      
      logger.debug(`成功加载 ${logPrefix}${pairs.length} 个历史交易对`);
      return new Set(pairs);
    }
  } catch (error) {
    logger.error(`读取${exchangeId ? ` ${exchangeId}` : ''} 历史数据失败: ${error.message}`);
  }
  
  logger.debug(`未找到${exchangeId ? ` ${exchangeId}` : ''} 历史数据，将创建新的数据文件`);
  return new Set();
}

/**
 * 保存当前交易对数据
 * @param {Set} pairs - 交易对集合
 * @param {string} exchangeId - 交易所ID（可选，不传则使用原始单交易所逻辑）
 */
function savePairs(pairs, exchangeId = null) {
  try {
    ensureDataDirectory();
    
    let targetFile;
    let logPrefix;
    
    if (exchangeId) {
      // 多交易所模式
      targetFile = path.join(multiExchangeDataPath, `${exchangeId}_pairs.json`);
      logPrefix = `${exchangeId} `;
    } else {
      // 原始单交易所模式（向后兼容）
      targetFile = dataFilePath;
      logPrefix = '';
    }
    
    const pairsArray = [...pairs];
    const saveData = {
      timestamp: new Date().toISOString(),
      exchange: exchangeId || 'upbit', // 默认标记为upbit以保持兼容性
      count: pairsArray.length,
      pairs: pairsArray
    };
    
    fs.writeFileSync(targetFile, JSON.stringify(saveData, null, 2));
    logger.debug(`成功保存 ${logPrefix}${pairsArray.length} 个交易对到文件`);
  } catch (error) {
    logger.error(`保存${exchangeId ? ` ${exchangeId}` : ''} 数据失败: ${error.message}`);
  }
}

/**
 * 记录监控日志
 * @param {Object} logEntry - 日志条目
 * @param {Date} logEntry.timestamp - 时间戳
 * @param {number} logEntry.totalPairs - 总交易对数量
 * @param {Array} logEntry.newPairs - 新增交易对
 * @param {boolean} logEntry.success - 检查是否成功
 * @param {string} logEntry.error - 错误信息（如果有）
 */
function logMonitorActivity(logEntry) {
  try {
    ensureDataDirectory();
    
    let logs = [];
    if (fs.existsSync(monitorLogPath)) {
      const data = fs.readFileSync(monitorLogPath, 'utf8');
      logs = JSON.parse(data);
    }
    
    // 添加新日志条目
    logs.push({
      ...logEntry,
      timestamp: logEntry.timestamp || new Date().toISOString()
    });
    
    // 只保留最近7天的日志（避免文件过大）
    const sevenDaysAgo = new Date();
    sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
    logs = logs.filter(log => new Date(log.timestamp) > sevenDaysAgo);
    
    fs.writeFileSync(monitorLogPath, JSON.stringify(logs, null, 2));
    logger.debug(`监控日志已记录，当前保存 ${logs.length} 条记录`);
  } catch (error) {
    logger.error(`记录监控日志失败: ${error.message}`);
  }
}

/**
 * 获取指定时间范围内的监控日志
 * @param {Date} startTime - 开始时间
 * @param {Date} endTime - 结束时间
 * @returns {Array} 日志条目数组
 */
function getMonitorLogs(startTime, endTime) {
  try {
    ensureDataDirectory();
    
    if (!fs.existsSync(monitorLogPath)) {
      return [];
    }
    
    const data = fs.readFileSync(monitorLogPath, 'utf8');
    const logs = JSON.parse(data);
    
    return logs.filter(log => {
      const logTime = new Date(log.timestamp);
      return logTime >= startTime && logTime <= endTime;
    });
  } catch (error) {
    logger.error(`读取监控日志失败: ${error.message}`);
    return [];
  }
}

/**
 * 获取最近24小时的监控统计
 * @returns {Object} 统计信息
 */
function getLast24HoursStats() {
  const now = new Date();
  const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
  
  const logs = getMonitorLogs(yesterday, now);
  
  const stats = {
    totalChecks: logs.length,
    successfulChecks: logs.filter(log => log.success).length,
    failedChecks: logs.filter(log => !log.success).length,
    newPairsFound: logs.reduce((total, log) => total + (log.newPairs?.length || 0), 0),
    allNewPairs: logs.flatMap(log => log.newPairs || []),
    errors: logs.filter(log => log.error).map(log => ({ 
      timestamp: log.timestamp, 
      error: log.error 
    })),
    firstCheck: logs.length > 0 ? logs[0].timestamp : null,
    lastCheck: logs.length > 0 ? logs[logs.length - 1].timestamp : null
  };
  
  // 去重新增交易对
  stats.uniqueNewPairs = [...new Set(stats.allNewPairs)];
  
  return stats;
}

/**
 * 获取数据文件路径
 * @returns {string} 数据文件路径
 */
function getDataFilePath() {
  return dataFilePath;
}

/**
 * 获取监控日志文件路径
 * @returns {string} 监控日志文件路径
 */
function getMonitorLogPath() {
  return monitorLogPath;
}

module.exports = {
  loadPreviousPairs,
  savePairs,
  getDataFilePath,
  logMonitorActivity,
  getMonitorLogs,
  getLast24HoursStats,
  getMonitorLogPath
};
